home *** CD-ROM | disk | FTP | other *** search
/ Shareware Grab Bag / Shareware Grab Bag.iso / 011 / lmouse.arc / LSET.C < prev    next >
Encoding:
C/C++ Source or Header  |  1986-06-14  |  17.0 KB  |  659 lines
  1. /*          By Mark E. Johnson. 2272-F Benson Ave. St. Paul MN 55116  */
  2.  
  3. /* COMPILE with Lattice Small Model compiler                          */ 
  4. /* LINK C+LSET+KEY_SCAN, LSET,, LC                                    */
  5.  
  6. #include <stdio.h>       /* 6/14/86 */
  7. #include <dos.h>
  8.  
  9. #define TRUE  1
  10. #define FALSE 0
  11. #define VOID int              /* Makes it look like a better compiler */
  12.  
  13. union REGS regs;              /* word structure for registers */
  14. struct SREGS sregs;           /* byte structure for registers */
  15.  
  16. typedef struct {              /* Long Pointer for Small Model */
  17.      unsigned int offset;
  18.      unsigned int segment;
  19. } lptr;
  20.  
  21. struct config_string {
  22.      char      press1[60],
  23.                release1[60],
  24.                press2[60],
  25.                release2[60],
  26.                press3[60],
  27.                release3[60],
  28.                up[8],
  29.                down[8],
  30.                left[8],
  31.                right[8];
  32.  
  33.   /* The following must be set to the length of the above strings */
  34.  
  35.      int       Lpress1,       /* length of press1 */
  36.                Lrel1,
  37.                Lpress2,
  38.                Lrel2,
  39.                Lpress3,
  40.                Lrel3,
  41.                Lup,
  42.                Ldown,
  43.                Lleft,
  44.                Lright;
  45.  
  46. };
  47.  
  48. struct config_string mousekeys;
  49.  
  50. int x_scale, y_scale, h;
  51. int quit = 0;
  52. int videoseg;  /* points to $B000 or $B800  for color or mono */
  53. int line, column;
  54. int key_scan();     /* from KEY_SCAN.ASM */
  55.  
  56.  
  57. main()
  58. {
  59.      unsigned i, d, noofbuttons;
  60.      int status;
  61.      int horiz, vert;
  62.      int buttonstatus, buttonpresscount;
  63.      char c;
  64.  
  65.      setvideoseg();
  66.      clrs();
  67.      flush_kbd();
  68.  
  69.      writeat( 6,0,7,"     Mouse Forward");         /* 6 */
  70.      writeat( 7,0,7,"     Mouse Backward");        /* 7 */
  71.      writeat( 8,0,7,"     Mouse Left");            /* 8 */
  72.      writeat( 9,0,7,"     Mouse Right");           /* 9 */
  73.      writeat(10,0,7,"                                          EXIT");
  74.      writeat(11,0,7,"     Button 1 Down");         /* 11 */
  75.      writeat(12,0,7,"     Button 1 Up");           /* 12 */
  76. /*   writeat(13,0,7,"                                          LOAD"); */
  77.      writeat(14,0,7,"     Button 2 Down");         /* 14 */
  78.      writeat(15,0,7,"     Button 2 Up");           /* 15 */
  79. /*   writeat(16,0,7,"                                          SAVE"); */
  80.      writeat(17,0,7,"     Button 3 Down");         /* 17 */
  81.      writeat(18,0,7,"     Button 3 Up");           /* 18 */
  82.      writeat(20,0,7,"     X scale 1-9");           /* 20 */
  83.      writeat(21,0,7,"     Y scale 1-9");           /* 21 */
  84.  
  85.      writeat(1,1,0x70,"Please wait...");
  86.      flagreset(&status, &noofbuttons);
  87.      setmousemode(0);
  88.      writeat(1,1,7,"               ");
  89.      showcursor();
  90.  
  91.      horiz = 0;
  92.      vert  = 0;
  93.      quit  = 0;
  94.      for( ; quit != 1 ;)
  95.      {
  96.           buttonstatus = 0;   /* left button */
  97.           WAI("Waiting for Button");
  98.           while (buttonstatus == 0)
  99.                getposbut(&buttonstatus, &horiz, &vert);
  100.  
  101.           for (i=1; i < 10000; i++)    /* Debounce delay */
  102.                h=i;
  103.  
  104.           if (buttonstatus > 0)
  105.           {
  106.                writeat(1,1,0x70,"Enter Sequence...");
  107.                switch(vert)
  108.                {
  109.                case 48 :
  110.                     mousekeys.Lup = kbd_gets(6,22,mousekeys.up,8);
  111.                     break;
  112.                case 56 :
  113.                     mousekeys.Ldown = kbd_gets(7,22,mousekeys.down,8);
  114.                     break;
  115.                case 64 :
  116.                     mousekeys.Lleft = kbd_gets(8,22,mousekeys.left,8);
  117.                     break;
  118.                case 72 :
  119.                     mousekeys.Lright = kbd_gets(9,22,mousekeys.right,8);
  120.                     break;
  121.                case 80 : quit = 1;
  122.                          break;
  123.                case 88 :
  124.                     mousekeys.Lpress1 = kbd_gets(11,22,mousekeys.press1,60);
  125.                     break;
  126.                case 96 :
  127.                     mousekeys.Lrel1 = kbd_gets(12,22,mousekeys.release1,60);
  128.                     break;
  129.                case 104 : /* load */
  130.                     break;
  131.                case 112 :
  132.                     mousekeys.Lpress2 = kbd_gets(14,22,mousekeys.press2,60);
  133.                     break;
  134.                case 120 :
  135.                     mousekeys.Lrel2 = kbd_gets(15,22,mousekeys.release2,60);
  136.                     break;
  137.                case 128 :
  138.                     /* save */
  139.                     break;
  140.                case 136 :
  141.                     mousekeys.Lpress3 = kbd_gets(17,22,mousekeys.press3,60);
  142.                     break;
  143.                case 144 :
  144.                     mousekeys.Lrel3 = kbd_gets(18,22,mousekeys.release3,60);
  145.                     break;
  146.                case 160 :
  147.                     gotoxy(20,22);
  148.                     writeat(20,22,0x70,"      X scale         ");
  149.                     x_scale = getche() & 0x0F;
  150.                     writeat(20,23,7,"                      ");
  151.                     break;
  152.                case 168 :
  153.                     gotoxy(21,22);
  154.                     writeat(21,22,0x70,"      Y scale         ");
  155.                     y_scale = getche() & 0x0F;
  156.                     writeat(21,23,7,"                      ");
  157.                }  /* switch */
  158.  
  159.                writeat(1,1,7,"                 ");
  160.                setcursorpos(horiz, vert);
  161.                showcursor();
  162.       } /* if buttonstatus */
  163.  
  164.      }
  165.      WAI("Resetting Mouse");
  166.      hidecursor();
  167.      flagreset(&status, &noofbuttons);
  168.  
  169.      WAI("Programming Mouse");
  170.      setkeybase(3,&mousekeys,x_scale,y_scale);
  171.      setmousemode(1);
  172.      gotoxy(24,0);
  173. }
  174.  
  175.  
  176. VOID scan_out(c, scan)
  177. char c;
  178. int scan;
  179. {
  180.      if (c == 0)         /* extended code follows */
  181.           switch(scan)
  182.           {
  183.                case 0x47 :    vputs(0x70, "<HOME>");
  184.                               break;
  185.                case 0x48 :    vputs(0x70, "<UP>");
  186.                               break;
  187.                case 0x49 :    vputs(0x70, "<PgUp>");
  188.                               break;
  189.                case 0x4B :    vputs(0x70, "<LEFT>");
  190.                               break;
  191.                case 0x4D :    vputs(0x70, "<RIGHT>");
  192.                               break;
  193.                case 0x4F :    vputs(0x70, "<End>");
  194.                               break;
  195.                case 0x50 :    vputs(0x70, "<DOWN>");
  196.                               break;
  197.                case 0x51 :    vputs(0x70, "<PgDwn>");
  198.                               break;
  199.                case 0x52 :    vputs(0x70, "<Ins>");
  200.                               break;
  201.                case 0x53 :    vputs(0x70, "<Del>");
  202.                               break;
  203.                default   :    vputc(0x70, c);
  204.           }
  205.      else
  206.      if ( c < 0x20 )     /* Control Character */
  207.      {
  208.           vputc(0x70,'^');
  209.           vputc(0x70,c+0x40);
  210.      }
  211. }
  212.  
  213.  
  214. int kbd_gets(x, y, string, maxlen)
  215. int x, y;
  216. char *string;
  217. int  maxlen;
  218. {
  219.      int c, scan, len, button, buttonstatus, horiz, vert;
  220.      int hold_vertical, i, h;
  221.  
  222.      vgotoxy(x, y);
  223.      clreol();
  224.      len = 0;
  225.      getposbut(&buttonstatus, &horiz, &hold_vertical);
  226.      do
  227.      {
  228.           while(key_scan() == 0 && buttonstatus == 0)
  229.                getposbut(&buttonstatus, &horiz, &vert);
  230.  
  231.           if (buttonstatus != 0)
  232.           {
  233.                WAI("Button Depressed");
  234.                c = 0;
  235.                scan = 0x3b;
  236.                vputs(0x70, "< Terminated >");
  237.                for (i=1; i < 10000; i++)
  238.                     h=i;           /* debounce */
  239.           }
  240.           else
  241.           {
  242.                WAI("Character Entered");
  243.                scan_kbd(&c, &scan);
  244.           }
  245.           if (c < 0x20)            /* Control character */
  246.                scan_out(c,scan);
  247.           else
  248.                vputc(0x70,c);
  249.           flush_kbd();
  250.           if (scan != 0x3B)
  251.           {
  252.                *string++ = c;
  253.                *string++ = scan;
  254.                len += 2;
  255.                if (len > maxlen)
  256.                     scan = 0x3B;
  257.           }
  258.      } while(scan != 0x3B);
  259.  
  260.      return(len);
  261. }  
  262.  
  263. /************* MOUSE FUNCTIONS ****************/
  264.  
  265. VOID flagreset(mousestatusptr, numberofbuttonsptr)
  266. int *mousestatusptr, *numberofbuttonsptr;
  267.  
  268. /*  Output AX --> Mouse status
  269.                   0 (FALSE) : mouse not installed
  270.                  -1 (TRUE)  : Mouse installed
  271.            BX --> Number of buttons   */
  272.  
  273. {
  274.      regs.x.ax = 0;
  275.      int86(0x33,®s,®s);
  276.      *mousestatusptr = regs.x.ax;
  277.      *numberofbuttonsptr = regs.x.bx;
  278. }
  279.  
  280. VOID showcursor()
  281. {
  282.      regs.x.ax = 1;
  283.      int86(0x33,®s,®s);
  284. }
  285.  
  286.  
  287. VOID hidecursor()
  288. {
  289.      regs.x.ax = 2;
  290.      int86(0x33,®s,®s);
  291. }
  292.  
  293. VOID getposbut(buttonstatus, horizontal, vertical)
  294. int *buttonstatus, *horizontal, *vertical;
  295.  
  296. /*  Output buttonstatus --> Button pressed
  297.            horizontal   --> horizontal cursor position
  298.            vertical     --> Vertical   cursor position  */
  299.  
  300. {
  301.      regs.x.ax = 3;
  302.      int86(0x33,®s,®s);
  303.      *buttonstatus=regs.x.bx;
  304.      *horizontal  =regs.x.cx;
  305.      *vertical    =regs.x.dx;
  306. }
  307.  
  308. VOID setcursorpos(horizontal,vertical)
  309. int horizontal, vertical;
  310. {
  311.      regs.x.ax=4;
  312.      regs.x.cx=horizontal;
  313.      regs.x.dx=vertical;
  314.      int86(0x33,®s,®s);
  315. }
  316.  
  317. VOID getbutpres(button,buttonstatus,buttonpresscount,horizontal,vertical)
  318. int button, *buttonstatus, *buttonpresscount, *horizontal, *vertical;
  319.  
  320. /*  Input  button       --> Button to check on
  321.  
  322.     Output buttonstatus --> Current Button pressed
  323.            buttonpresscount number of button presses
  324.            horizontal   --> horizontal cursor position
  325.            vertical     --> Vertical   cursor position  */
  326.  
  327. {
  328.      regs.x.ax=5;
  329.      regs.x.bx=button;
  330.      int86(0x33,®s,®s);
  331.      *buttonstatus = regs.x.ax;
  332.      *buttonpresscount = regs.x.bx;
  333.      *horizontal = regs.x.cx;
  334.      *vertical = regs.x.dx;
  335. }
  336.  
  337. VOID getbutrel(button,buttonstatus,buttonreleasecount,horizontal,vertical)
  338. int button, *buttonstatus, *buttonreleasecount, *horizontal, *vertical;
  339.  
  340. /*  Input  button       --> Button to check on
  341.  
  342.     Output buttonstatus --> Current button pressed
  343.            buttonpresscount number of button releases
  344.            horizontal   --> horizontal cursor position
  345.            vertical     --> Vertical   cursor position  */
  346.  
  347. {
  348.      regs.x.ax=6;
  349.      regs.x.bx=button;
  350.      int86(0x33,®s,®s);
  351.      *buttonstatus = regs.x.ax;
  352.      *buttonreleasecount = regs.x.bx;
  353.      *horizontal = regs.x.cx;
  354.      *vertical = regs.x.dx;
  355. }
  356.  
  357. VOID sethorizontallimits(minpos, maxpos)
  358. int minpos, maxpos;
  359. {
  360.      regs.x.ax=7;
  361.      regs.x.cx=minpos;
  362.      regs.x.dx=maxpos;
  363.      int86(0x33,®s,®s);
  364. }
  365.  
  366. VOID setverticallimits(minpos, maxpos)
  367. int minpos, maxpos;
  368. {
  369.      regs.x.ax=8;
  370.      regs.x.cx=minpos;
  371.      regs.x.dx=maxpos;
  372.      int86(0x33,®s,®s);
  373. }
  374.  
  375.  
  376. VOID readmotioncounters(horizontal, vertical)
  377.  
  378. /* returns the number of steps since last call */
  379.  
  380. int *horizontal, *vertical;
  381. {
  382.      regs.x.ax=11;
  383.      int86(0x33,®s,®s);
  384.      *horizontal = regs.x.cx;
  385.      *vertical   = regs.x.dx;
  386. }
  387.  
  388. VOID setmickeysperpixel(horpix, verpix)
  389.  
  390. unsigned int horpix, verpix;
  391. {
  392.      regs.x.ax=15;
  393.      regs.x.cx=horpix;
  394.      regs.x.dx=verpix;
  395.      int86(0x33,®s,®s);
  396. }
  397.  
  398.  
  399. int getmousemode()    /* 0 = mousebase, 1 = keybase, 2 = inactive */
  400. {
  401.      regs.x.ax=32;
  402.      int86(0x33,®s,®s);
  403.      return(regs.x.bx);
  404. }
  405.  
  406.  
  407. VOID setmousemode(mode)
  408. int mode;
  409. {
  410.      regs.x.ax=33;
  411.      regs.x.bx=mode;
  412.      int86(0x33,®s,®s);
  413. }
  414.  
  415.  
  416. VOID setkeybase(mode,keys,x,y)
  417.  
  418. /* set KEYBASE mode,   0 = use specified config, 1 = default */
  419.  
  420. int mode;
  421. struct config_string *keys;
  422. int x, y;
  423.  
  424. {
  425.      int dataseg;
  426.      struct keytype {
  427.           int       pbut1len;  lptr      pbut1ptr;
  428.           int       rbut1len;  lptr      rbut1ptr;
  429.           int       pbut2len;  lptr      pbut2ptr;
  430.           int       rbut2len;  lptr      rbut2ptr;
  431.           int       pbut3len;  lptr      pbut3ptr;
  432.           int       rbut3len;  lptr      rbut3ptr;
  433.           int       uplen;     lptr      upptr;
  434.           int       downlen;   lptr      downptr;
  435.           int       leftlen;   lptr      leftptr;
  436.           int       rightlen;  lptr      rightptr;
  437.           int       xscale, yscale;
  438.      };
  439.  
  440.      struct keytype keybase;
  441.  
  442.      segread(&sregs);    /* Read our current segment registers */
  443.      dataseg=sregs.ds;
  444.  
  445.      if (mode != 1)
  446.      {
  447.           keybase.pbut1len              = keys->Lpress1;
  448.           keybase.pbut1ptr.offset     = (int) &(keys->press1);
  449.           keybase.pbut1ptr.segment    = dataseg;
  450.  
  451.           keybase.rbut1len            = keys->Lrel1;
  452.           keybase.rbut1ptr.offset     = (int) &(keys->release1);
  453.           keybase.rbut1ptr.segment    = dataseg;
  454.  
  455.           keybase.pbut2len            = keys->Lpress2;
  456.           keybase.pbut2ptr.offset     = (int) &(keys->press2);
  457.           keybase.pbut2ptr.segment    = dataseg;
  458.  
  459.           keybase.rbut2len            = keys->Lrel2;
  460.           keybase.rbut2ptr.offset     = (int) &(keys->release2);
  461.           keybase.rbut2ptr.segment    = dataseg;
  462.  
  463.           keybase.pbut3len            = keys->Lpress3;
  464.           keybase.pbut3ptr.offset     = (int) &(keys->press3);
  465.           keybase.pbut3ptr.segment    = dataseg;
  466.  
  467.           keybase.rbut3len            = keys->Lrel3;
  468.           keybase.rbut3ptr.offset     = (int) &(keys->release3);
  469.           keybase.rbut3ptr.segment    = dataseg;
  470.  
  471.           keybase.uplen               = keys->Lup;
  472.           keybase.upptr.offset        = (int) &(keys->up);
  473.           keybase.upptr.segment       = dataseg;
  474.  
  475.           keybase.downlen             = keys->Ldown;
  476.           keybase.downptr.offset      = (int) &(keys->down);
  477.           keybase.downptr.segment     = dataseg;
  478.  
  479.           keybase.leftlen             = keys->Lleft;
  480.           keybase.leftptr.offset      = (int) &(keys->left);
  481.           keybase.leftptr.segment     = dataseg;
  482.  
  483.           keybase.rightlen            = keys->Lright;
  484.           keybase.rightptr.offset     = (int) &(keys->right);
  485.           keybase.rightptr.segment    = dataseg;
  486.  
  487.           keybase.xscale = x;
  488.           keybase.yscale = y;
  489.  
  490.           regs.x.dx = (int) &keybase;
  491.           sregs.es  = dataseg;
  492.      }
  493.  
  494.      regs.x.ax=35;
  495.      regs.x.bx=mode;
  496.      int86(0x33,®s,®s);
  497. }
  498.  
  499. /****************** Very Low Level BIOS CALLS ****************/
  500.  
  501. VOID setmode(mode)    /* 640x200 = 2,   80x24 text = 6 */
  502. char mode;
  503. {
  504.      regs.h.ah=0;
  505.      regs.h.al=mode;
  506.      int86(0x10,®s,®s);
  507. }
  508.  
  509.  
  510. VOID scan_kbd(c,scan)    /* Returns Ascii Key code and/or scan code */
  511. int *c, *scan;
  512. {
  513.      regs.h.ah = 0;
  514.      int86(0x16, ®s, ®s);
  515.      *scan = regs.h.ah;
  516.      *c    = regs.h.al;  /* zero if not Ascii */
  517. }
  518.  
  519. VOID flush_kbd()    /* Make sure keyboard buffer is clear */
  520. {
  521.      int c,scan;
  522.      while( key_scan() )
  523.      {
  524.           scan_kbd(c,scan);
  525.           writeat(2,50,0x07,"Flush"); 
  526.      }
  527. }
  528.                 
  529. VOID gotoxy(row, col)
  530. int row, col;
  531. {
  532.     regs.h.dh = row;
  533.     regs.h.dl = col;
  534.     regs.h.bh = 0;
  535.     regs.h.ah = 2;
  536.     int86(0x10, ®s, ®s);
  537. }
  538.  
  539. VOID get_cur(row, col)
  540. int *row, *col;
  541. {
  542.     regs.h.bh = 0;
  543.     regs.h.ah = 3;
  544.     int86(0x10, ®s, ®s);
  545.     *row=regs.h.dh;
  546.     *col=regs.h.dl;
  547.     return;
  548. }
  549.  
  550. int colormonitor()   /* Returns TRUE if a Color monitor is installed */
  551. {
  552.    regs.h.ah = 15;
  553.    int86(0x10,®s,®s);
  554.  
  555.    if (regs.h.al == 7)
  556.      return(FALSE);
  557.    else return(TRUE);
  558. }
  559.  
  560.  
  561. VOID setvideoseg()
  562. {
  563.  
  564.   if (colormonitor() == TRUE)
  565.   {
  566.     videoseg = 0xB800;
  567.   }
  568.   else
  569.     videoseg = 0xB000;
  570.  
  571. }
  572.  
  573. VOID writeat(x, y, mode, s)  /*   MODE VALUES
  574.                                Norm:  0x07  Rev:   0x70  Hi:    0x0F
  575.                                RevHi: 0x78  Blink: 0x87
  576.                              */
  577. int x, y, mode;
  578. char *s;
  579. {
  580.    vgotoxy(x, y);
  581.    vputs(mode,s);
  582. }
  583.  
  584. VOID vputc(mode,c)
  585. int mode;
  586. char c;
  587. {
  588.      char m, c2;
  589.      int offset;
  590.  
  591.      m = mode;
  592.      c2 = c;
  593.      offset = 2*(line*80+column);
  594.      poke(videoseg, offset, &c2, 1);
  595.      poke(videoseg, offset+1, &m, 1);
  596.      column++;
  597. }
  598.  
  599. VOID vputs(mode,s)
  600. int mode;
  601. char *s;
  602. {
  603.      while(*s)
  604.           vputc(mode,*s++);
  605.           
  606. }
  607.  
  608. VOID vgotoxy(x, y)
  609. int x, y;
  610. {
  611.      line = x;
  612.      column = y;
  613. }
  614.  
  615.           
  616. VOID clrs()
  617. {
  618.     int i;
  619.     vgotoxy(0, 0);
  620.     for(i=0; i <= 24; i++)
  621.     {
  622.        vgotoxy(i,0);
  623.        clreol();
  624.     }
  625.     line = 0;
  626.     column = 0;
  627. }
  628.  
  629.  
  630. VOID clreol()
  631. {
  632.      int i, x, y;
  633.      
  634.      x = line;
  635.      y = column;
  636.      for(i=column; i <= 79; i++)
  637.           vputc(0x07,' ');
  638.      line = x;
  639.      column = y;
  640. }
  641.  
  642.  
  643. VOID WAI(s)     /* Where Am I */
  644. char *s;
  645. {
  646.      int x, y;
  647.  
  648.      x = line;
  649.      y = column;
  650.  
  651.      vgotoxy(1,50);
  652.      vputs(0x07,"                           ");
  653.      vgotoxy(1,50);
  654.      vputs(0x07,s);
  655.  
  656.      line = x;
  657.      column = y;
  658. }
  659.